/**
 * API接口模块
 * 处理与后端的数据交互
 */

import axios from 'axios'
import { logger } from '../utils/logger'

// 创建axios实例
const api = axios.create({
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  (config) => {
    logger.debug('发送请求:', config.url, config.params)
    return config
  },
  (error) => {
    logger.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  (response) => {
    logger.debug('收到响应:', response.config.url, response.status)
    return response
  },
  (error) => {
    logger.error('响应错误:', error)
    
    // 统一错误处理
    let errorMessage = '网络请求失败'
    
    if (error.response) {
      // 服务器返回错误状态码
      errorMessage = `服务器错误: ${error.response.status}`
      if (error.response.data && error.response.data.message) {
        errorMessage += ` - ${error.response.data.message}`
      }
    } else if (error.request) {
      // 请求发送但没有收到响应
      errorMessage = '网络连接超时，请检查网络连接'
    } else {
      // 其他错误
      errorMessage = error.message || '未知错误'
    }
    
    return Promise.reject(new Error(errorMessage))
  }
)

/**
 * 备用服务器数据（当远程API不可用时使用）
 */
const fallbackServers = [
  
]

/**
 * 服务器相关API
 */
export const serverApi = {
  /**
   * 获取服务器列表
   * @returns {Promise<Array>} 服务器列表
   */
  async getServerList() {
    // 使用代理路径避免CORS问题
    const urls = [
      '/external-api/index.php/serverV2t/lists/?account=12323&channelId=95_15&type=3&per_page=995',
      '/external-api/index.php/serverV2t/lists/?account=12323&channelId=118_1&type=3&per_page=995'
    ]
    
    const allServers = []
    let lastError = null
    
    // 定义单次请求函数
    const fetchFromUrls = async () => {
      const responses = await Promise.allSettled(
        urls.map(url => {
          logger.debug('正在请求服务器列表:', url)
          return api.get(url, { 
            timeout: 15000,  // 增加超时时间
            headers: {
              'Accept': 'application/json',
              'Cache-Control': 'no-cache'
            }
          })
        })
      )
      
      let successCount = 0
      const errors = []
      
      for (const [index, response] of responses.entries()) {
        if (response.status === 'fulfilled') {
          const data = response.value.data
          logger.debug(`URL ${index + 1} 响应成功:`, data ? '有数据' : '无数据')
          
          if (data && data.message && data.message.server_list) {
            allServers.push(...data.message.server_list)
            successCount++
          } else {
            logger.warn(`URL ${index + 1} 数据格式异常:`, data)
            errors.push(`URL ${index + 1}: 数据格式异常`)
          }
        } else {
          const error = response.reason
          logger.error(`URL ${index + 1} 请求失败:`, error.message)
          errors.push(`URL ${index + 1}: ${error.message}`)
        }
      }
      
      if (allServers.length === 0) {
        const errorMsg = `所有API端点都失败了。错误详情: ${errors.join('; ')}`
        throw new Error(errorMsg)
      }
      
      logger.info(`成功获取服务器数据，共 ${allServers.length} 个服务器`)
      return allServers
    }
    
    try {
      // 直接获取远程数据，不使用重试机制
      return await fetchFromUrls()
      
    } catch (error) {
      lastError = error
      logger.error('获取远程服务器列表失败:', error.message)
      
      // 检查是否是网络连接问题
      const isNetworkError = error.message.includes('Network Error') || 
                            error.message.includes('timeout') || 
                            error.message.includes('ENOTFOUND') ||
                            error.message.includes('ERR_NETWORK')
      
      if (isNetworkError) {
        logger.warn('检测到网络问题，尝试使用备用服务器列表')
        
        // 返回备用数据，但仍然抛出警告
        const warningMsg = `网络连接问题，已切换到备用服务器列表。原始错误: ${error.message}`
        logger.warn(warningMsg)
        
        // 返回备用数据和错误信息
        return {
          servers: fallbackServers,
          isFromFallback: true,
          originalError: error.message
        }
      }
      
      // 其他类型的错误，尝试备用方案
      logger.warn('使用备用服务器列表')
      return {
        servers: fallbackServers,
        isFromFallback: true,
        originalError: error.message
      }
    }
  },

  /**
   * 检查服务器API健康状态
   * @returns {Promise<Object>} 健康状态信息
   */
  async checkHealth() {
    // 使用代理路径进行健康检查
    const urls = [
      '/external-api/index.php/serverV2t/lists/?account=12323&channelId=95_15&type=3&per_page=995',
      '/external-api/index.php/serverV2t/lists/?account=12323&channelId=118_1&type=3&per_page=995'
    ]
    
    const results = await Promise.allSettled(
      urls.map(async (url, index) => {
        const start = Date.now()
        try {
          const response = await api.get(url, { timeout: 5000 })
          const duration = Date.now() - start
          return {
            url: `API ${index + 1}`,
            status: 'success',
            responseTime: duration,
            statusCode: response.status
          }
        } catch (error) {
          const duration = Date.now() - start
          return {
            url: `API ${index + 1}`,
            status: 'failed',
            responseTime: duration,
            error: error.message
          }
        }
      })
    )
    
    return results.map(result => result.value)
  }
}

/**
 * 活动相关API
 */
export const campApi = {
  /**
   * 获取活动数据
   * @param {string} pzoList - 服务器参数列表 (platform_zone_opentime,...)
   * @param {number} startTime - 开始时间戳（秒）
   * @param {number} endTime - 结束时间戳（秒）
   * @returns {Promise<any>} 活动数据
   */
  async getCampData(pzoList: string, startTime: number, endTime: number) {
    try {
      // 构建请求URL
      const url = '/api/dev/camp_show/camp_show'
      const params = {
        p_z_o_list: pzoList,
        start_time: startTime,
        end_time: endTime
      }
      
      logger.debug('🚀 [Camp API] 开始请求活动数据')
      logger.debug('📋 [Camp API] 请求参数:', {
        url,
        params,
        服务器列表: pzoList.split(','),
        开始时间: new Date(startTime * 1000).toLocaleString('zh-CN'),
        结束时间: new Date(endTime * 1000).toLocaleString('zh-CN'),
        时间范围天数: Math.ceil((endTime - startTime) / 86400)
      })
      
      const response = await api.get(url, { params })
      const data = response.data
      
      logger.debug('📦 [Camp API] 原始响应数据:', {
        状态码: response.status,
        响应头: response.headers,
        数据类型: typeof data,
        数据长度: typeof data === 'string' ? data.length : (Array.isArray(data) ? data.length : '对象'),
        数据预览: typeof data === 'string' ? data.substring(0, 200) + '...' : data
      })
      
      if (!data) {
        throw new Error('服务器返回空数据')
      }
      
      if (data.error) {
        logger.error('❌ [Camp API] 服务器返回错误:', data.error)
        throw new Error(data.error)
      }
      
      // 处理不同的数据格式
      let result = data.result || data
      
      logger.debug('✅ [Camp API] 处理后的数据:', {
        最终数据类型: typeof result,
        最终数据长度: typeof result === 'string' ? result.length : (Array.isArray(result) ? result.length : '对象'),
        是否为Erlang格式: typeof result === 'string' && result.includes('[{'),
        数据示例: typeof result === 'string' ? result.substring(0, 300) + '...' : result
      })
      
      return result
      
    } catch (error) {
      logger.error('❌ [Camp API] 获取活动数据失败:', {
        错误类型: error.constructor.name,
        错误消息: error.message,
        错误堆栈: error.stack,
        请求参数: { pzoList, startTime, endTime }
      })
      throw error
    }
  }
}

/**
 * 通用API工具函数
 */
export const apiUtils = {
  /**
   * 检查网络连接
   * @returns {Promise<boolean>} 是否连接正常
   */
  async checkConnection() {
    try {
      await api.get('/api/health', { timeout: 5000 })
      return true
    } catch {
      return false
    }
  }
}

export default api
